package hello

import (
	"context"
	"github.com/cloudwego/hertz/pkg/app"
	"github.com/cloudwego/hertz/pkg/app/client"
	"github.com/cloudwego/hertz/pkg/common/config"
	"github.com/cloudwego/hertz/pkg/common/hlog"
	"github.com/cloudwego/hertz/pkg/protocol/consts"
	"primus/consumer-service/service/hello/hello_service"
	"time"
)

func GetH(ctx context.Context, c *app.RequestContext) {
	var q int32 = 100000
	//cc, _ := nacos.NewNacosConfig("121.37.173.206", 8848, "")
	//r := nacoscli.NewNacosResolver(cc)

	cli, _ := hello_service.NewHelloServiceClient(
		"http://producer-service",
		//"http://127.0.0.1:9809",
		//hello_service.WithHertzClientMiddleware(), // 指定 client 的中间件
		hello_service.WithHertzClientOption(
			//client.WithDialTimeout(1 * time.Second),//连接建立超时时间，默认 1s
			client.WithWriteTimeout(500*time.Millisecond),       //写入数据超时时间，默认值：无限
			client.WithClientReadTimeout(2*time.Second),         //设置读取 response 的最长时间，默认无限长
			client.WithMaxConnWaitTimeout(100*time.Millisecond), //设置等待空闲连接的最大时间，默认不等待
			client.WithMaxIdleConnDuration(3*time.Second),       //空闲连接超时时间,当超时后会关闭该连接，默认10s
			client.WithMaxConnDuration(3*time.Second),           //设置连接存活的最大时长，超过这个时间的连接在完成当前请求后会被关闭，默认无限长
			client.WithMaxConnsPerHost(1000000),
			//client.WithRetryConfig (
			//	retry.WithMaxAttemptTimes(3), // 最大的尝试次数，包括初始调用
			//	retry.WithInitDelay(1 * time.Millisecond), // 初始延迟
			//	retry.WithMaxDelay(6 * time.Millisecond), // 最大延迟，不管重试多少次，策略如何，都不会超过这个延迟
			//	retry.WithMaxJitter(2 * time.Millisecond), // 延时的最大扰动，结合 RandomDelayPolicy 才会有效果
			//	/*
			//	   配置延迟策略，你可以选择下面四种中的任意组合，最后的结果为每种延迟策略的加和
			//	   FixedDelayPolicy 使用 retry.WithInitDelay 所设置的值 ，
			//	   BackOffDelayPolicy 在 retry.WithInitDelay 所设置的值的基础上随着重试次数的增加，指数倍数增长，
			//	   RandomDelayPolicy 生成 [0，2*time.Millisecond）的随机数值 ，2*time.Millisecond 为 retry.WithMaxJitter 所设置的值，
			//	   DefaultDelayPolicy 生成 0 值，如果单独使用则立刻重试，
			//	   retry.CombineDelay() 将所设置的延迟策略所生成的值加和，最后结果即为当前次重试的延迟时间，
			//	   第一次调用失败 -> 重试延迟：1 + 1<<1 + rand[0,2)ms -> 第二次调用失败 -> 重试延迟：min(1 + 1<<2 + rand[0,2) , 6)ms -> 第三次调用成功/失败
			//	*/
			//	retry.WithDelayPolicy(retry.CombineDelay(retry.FixedDelayPolicy, retry.BackOffDelayPolicy, retry.RandomDelayPolicy)),
			//),
		),
	)
	//cli.Use(sd.Discovery(nacos.NewNacosResolver(conf)))
	resp, rawResp, err := cli.GetH(
		context.Background(),
		&q,
		// 在发起调用的时候可指定请求级别的配置
		//config.
		config.WithSD(true),                      // 指定请求级别的设置，用来开启服务发现
		config.WithReadTimeout(2000*time.Second), // 指定请求读超时
	)
	if err != nil {
		hlog.Error(err)
		c.JSON(consts.StatusInternalServerError, err)
		return
	}
	hlog.Info(rawResp.StatusCode())
	hlog.Info(resp)
	c.JSON(consts.StatusOK, resp)
}

func GetH2(ctx context.Context, c *app.RequestContext) {
	//ctx, span := otel.Tracer("github.com/hertz-contrib/obs-opentelemetry").
	//	Start(context.Background(), "loop")
	var q int32 = 100000
	resp, rawResp, err := hello_service.GetH(
		ctx,
		&q,
		// 在发起调用的时候可指定请求级别的配置
		//config.
		config.WithSD(true),                      // 指定请求级别的设置，用来开启服务发现
		config.WithReadTimeout(100*time.Millisecond), // 指定请求读超时
	)
	//span.SetAttributes(attribute.String("body", string(rawResp.Body())))
	//span.End()

	//<-time.After(time.Second)
	//表示从 time.After(time.Second) 返回的通道中读取值，同时在等待 1 秒钟之后读取。time.After() 方法返回一个通道，
	//该通道在指定的时间后会向其中写入一个 time.Time 类型的值。因此，使用 <-time.After(time.Second)
	//表示在等待 1 秒钟之后从通道中读取这个值，实现了等待 1 秒钟的效果。如果没有读取这个值，或只是调用 time.Sleep() 等待，
	//程序将会一直阻塞在这里，浪费 CPU 资源。而使用通道则可以让程序在等待的同时执行其他任务，提高程序的效率。

	hello_service.Post(ctx, nil)
	if err != nil {
		hlog.Error(err)
		c.JSON(consts.StatusInternalServerError, err)
		return
	}
	hlog.Info(rawResp.StatusCode())
	hlog.Info(resp)
	c.JSON(consts.StatusOK, resp)
}
